// Code generated by MockGen. DO NOT EDIT.
// Source: cloudapi.pb.go

// Package mock_cloudpb is a generated GoMock package.
package mock_cloudpb

import (
	context "context"
	reflect "reflect"

	types "github.com/gogo/protobuf/types"
	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
	cloudpb "px.dev/pixie/src/api/proto/cloudpb"
	uuidpb "px.dev/pixie/src/api/proto/uuidpb"
)

// MockUserServiceClient is a mock of UserServiceClient interface.
type MockUserServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockUserServiceClientMockRecorder
}

// MockUserServiceClientMockRecorder is the mock recorder for MockUserServiceClient.
type MockUserServiceClientMockRecorder struct {
	mock *MockUserServiceClient
}

// NewMockUserServiceClient creates a new mock instance.
func NewMockUserServiceClient(ctrl *gomock.Controller) *MockUserServiceClient {
	mock := &MockUserServiceClient{ctrl: ctrl}
	mock.recorder = &MockUserServiceClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockUserServiceClient) EXPECT() *MockUserServiceClientMockRecorder {
	return m.recorder
}

// DeleteUser mocks base method.
func (m *MockUserServiceClient) DeleteUser(ctx context.Context, in *cloudpb.DeleteUserRequest, opts ...grpc.CallOption) (*cloudpb.DeleteUserResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteUser", varargs...)
	ret0, _ := ret[0].(*cloudpb.DeleteUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteUser indicates an expected call of DeleteUser.
func (mr *MockUserServiceClientMockRecorder) DeleteUser(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockUserServiceClient)(nil).DeleteUser), varargs...)
}

// GetUser mocks base method.
func (m *MockUserServiceClient) GetUser(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*cloudpb.UserInfo, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUser", varargs...)
	ret0, _ := ret[0].(*cloudpb.UserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUser indicates an expected call of GetUser.
func (mr *MockUserServiceClientMockRecorder) GetUser(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockUserServiceClient)(nil).GetUser), varargs...)
}

// GetUserAttributes mocks base method.
func (m *MockUserServiceClient) GetUserAttributes(ctx context.Context, in *cloudpb.GetUserAttributesRequest, opts ...grpc.CallOption) (*cloudpb.GetUserAttributesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserAttributes", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetUserAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserAttributes indicates an expected call of GetUserAttributes.
func (mr *MockUserServiceClientMockRecorder) GetUserAttributes(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAttributes", reflect.TypeOf((*MockUserServiceClient)(nil).GetUserAttributes), varargs...)
}

// GetUserSettings mocks base method.
func (m *MockUserServiceClient) GetUserSettings(ctx context.Context, in *cloudpb.GetUserSettingsRequest, opts ...grpc.CallOption) (*cloudpb.GetUserSettingsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserSettings", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetUserSettingsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserSettings indicates an expected call of GetUserSettings.
func (mr *MockUserServiceClientMockRecorder) GetUserSettings(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserSettings", reflect.TypeOf((*MockUserServiceClient)(nil).GetUserSettings), varargs...)
}

// SetUserAttributes mocks base method.
func (m *MockUserServiceClient) SetUserAttributes(ctx context.Context, in *cloudpb.SetUserAttributesRequest, opts ...grpc.CallOption) (*cloudpb.SetUserAttributesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetUserAttributes", varargs...)
	ret0, _ := ret[0].(*cloudpb.SetUserAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetUserAttributes indicates an expected call of SetUserAttributes.
func (mr *MockUserServiceClientMockRecorder) SetUserAttributes(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAttributes", reflect.TypeOf((*MockUserServiceClient)(nil).SetUserAttributes), varargs...)
}

// UpdateUser mocks base method.
func (m *MockUserServiceClient) UpdateUser(ctx context.Context, in *cloudpb.UpdateUserRequest, opts ...grpc.CallOption) (*cloudpb.UserInfo, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUser", varargs...)
	ret0, _ := ret[0].(*cloudpb.UserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUser indicates an expected call of UpdateUser.
func (mr *MockUserServiceClientMockRecorder) UpdateUser(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockUserServiceClient)(nil).UpdateUser), varargs...)
}

// UpdateUserSettings mocks base method.
func (m *MockUserServiceClient) UpdateUserSettings(ctx context.Context, in *cloudpb.UpdateUserSettingsRequest, opts ...grpc.CallOption) (*cloudpb.UpdateUserSettingsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserSettings", varargs...)
	ret0, _ := ret[0].(*cloudpb.UpdateUserSettingsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserSettings indicates an expected call of UpdateUserSettings.
func (mr *MockUserServiceClientMockRecorder) UpdateUserSettings(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserSettings", reflect.TypeOf((*MockUserServiceClient)(nil).UpdateUserSettings), varargs...)
}

// MockUserServiceServer is a mock of UserServiceServer interface.
type MockUserServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockUserServiceServerMockRecorder
}

// MockUserServiceServerMockRecorder is the mock recorder for MockUserServiceServer.
type MockUserServiceServerMockRecorder struct {
	mock *MockUserServiceServer
}

// NewMockUserServiceServer creates a new mock instance.
func NewMockUserServiceServer(ctrl *gomock.Controller) *MockUserServiceServer {
	mock := &MockUserServiceServer{ctrl: ctrl}
	mock.recorder = &MockUserServiceServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockUserServiceServer) EXPECT() *MockUserServiceServerMockRecorder {
	return m.recorder
}

// DeleteUser mocks base method.
func (m *MockUserServiceServer) DeleteUser(arg0 context.Context, arg1 *cloudpb.DeleteUserRequest) (*cloudpb.DeleteUserResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUser", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.DeleteUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteUser indicates an expected call of DeleteUser.
func (mr *MockUserServiceServerMockRecorder) DeleteUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockUserServiceServer)(nil).DeleteUser), arg0, arg1)
}

// GetUser mocks base method.
func (m *MockUserServiceServer) GetUser(arg0 context.Context, arg1 *uuidpb.UUID) (*cloudpb.UserInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUser", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.UserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUser indicates an expected call of GetUser.
func (mr *MockUserServiceServerMockRecorder) GetUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockUserServiceServer)(nil).GetUser), arg0, arg1)
}

// GetUserAttributes mocks base method.
func (m *MockUserServiceServer) GetUserAttributes(arg0 context.Context, arg1 *cloudpb.GetUserAttributesRequest) (*cloudpb.GetUserAttributesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAttributes", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetUserAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserAttributes indicates an expected call of GetUserAttributes.
func (mr *MockUserServiceServerMockRecorder) GetUserAttributes(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAttributes", reflect.TypeOf((*MockUserServiceServer)(nil).GetUserAttributes), arg0, arg1)
}

// GetUserSettings mocks base method.
func (m *MockUserServiceServer) GetUserSettings(arg0 context.Context, arg1 *cloudpb.GetUserSettingsRequest) (*cloudpb.GetUserSettingsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserSettings", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetUserSettingsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserSettings indicates an expected call of GetUserSettings.
func (mr *MockUserServiceServerMockRecorder) GetUserSettings(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserSettings", reflect.TypeOf((*MockUserServiceServer)(nil).GetUserSettings), arg0, arg1)
}

// SetUserAttributes mocks base method.
func (m *MockUserServiceServer) SetUserAttributes(arg0 context.Context, arg1 *cloudpb.SetUserAttributesRequest) (*cloudpb.SetUserAttributesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUserAttributes", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.SetUserAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetUserAttributes indicates an expected call of SetUserAttributes.
func (mr *MockUserServiceServerMockRecorder) SetUserAttributes(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAttributes", reflect.TypeOf((*MockUserServiceServer)(nil).SetUserAttributes), arg0, arg1)
}

// UpdateUser mocks base method.
func (m *MockUserServiceServer) UpdateUser(arg0 context.Context, arg1 *cloudpb.UpdateUserRequest) (*cloudpb.UserInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUser", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.UserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUser indicates an expected call of UpdateUser.
func (mr *MockUserServiceServerMockRecorder) UpdateUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockUserServiceServer)(nil).UpdateUser), arg0, arg1)
}

// UpdateUserSettings mocks base method.
func (m *MockUserServiceServer) UpdateUserSettings(arg0 context.Context, arg1 *cloudpb.UpdateUserSettingsRequest) (*cloudpb.UpdateUserSettingsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserSettings", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.UpdateUserSettingsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserSettings indicates an expected call of UpdateUserSettings.
func (mr *MockUserServiceServerMockRecorder) UpdateUserSettings(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserSettings", reflect.TypeOf((*MockUserServiceServer)(nil).UpdateUserSettings), arg0, arg1)
}

// MockOrganizationServiceClient is a mock of OrganizationServiceClient interface.
type MockOrganizationServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockOrganizationServiceClientMockRecorder
}

// MockOrganizationServiceClientMockRecorder is the mock recorder for MockOrganizationServiceClient.
type MockOrganizationServiceClientMockRecorder struct {
	mock *MockOrganizationServiceClient
}

// NewMockOrganizationServiceClient creates a new mock instance.
func NewMockOrganizationServiceClient(ctrl *gomock.Controller) *MockOrganizationServiceClient {
	mock := &MockOrganizationServiceClient{ctrl: ctrl}
	mock.recorder = &MockOrganizationServiceClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockOrganizationServiceClient) EXPECT() *MockOrganizationServiceClientMockRecorder {
	return m.recorder
}

// AddOrgIDEConfig mocks base method.
func (m *MockOrganizationServiceClient) AddOrgIDEConfig(ctx context.Context, in *cloudpb.AddOrgIDEConfigRequest, opts ...grpc.CallOption) (*cloudpb.AddOrgIDEConfigResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddOrgIDEConfig", varargs...)
	ret0, _ := ret[0].(*cloudpb.AddOrgIDEConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddOrgIDEConfig indicates an expected call of AddOrgIDEConfig.
func (mr *MockOrganizationServiceClientMockRecorder) AddOrgIDEConfig(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrgIDEConfig", reflect.TypeOf((*MockOrganizationServiceClient)(nil).AddOrgIDEConfig), varargs...)
}

// CreateInviteToken mocks base method.
func (m *MockOrganizationServiceClient) CreateInviteToken(ctx context.Context, in *cloudpb.CreateInviteTokenRequest, opts ...grpc.CallOption) (*cloudpb.InviteToken, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateInviteToken", varargs...)
	ret0, _ := ret[0].(*cloudpb.InviteToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateInviteToken indicates an expected call of CreateInviteToken.
func (mr *MockOrganizationServiceClientMockRecorder) CreateInviteToken(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInviteToken", reflect.TypeOf((*MockOrganizationServiceClient)(nil).CreateInviteToken), varargs...)
}

// CreateOrg mocks base method.
func (m *MockOrganizationServiceClient) CreateOrg(ctx context.Context, in *cloudpb.CreateOrgRequest, opts ...grpc.CallOption) (*uuidpb.UUID, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateOrg", varargs...)
	ret0, _ := ret[0].(*uuidpb.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateOrg indicates an expected call of CreateOrg.
func (mr *MockOrganizationServiceClientMockRecorder) CreateOrg(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrg", reflect.TypeOf((*MockOrganizationServiceClient)(nil).CreateOrg), varargs...)
}

// DeleteOrgIDEConfig mocks base method.
func (m *MockOrganizationServiceClient) DeleteOrgIDEConfig(ctx context.Context, in *cloudpb.DeleteOrgIDEConfigRequest, opts ...grpc.CallOption) (*cloudpb.DeleteOrgIDEConfigResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteOrgIDEConfig", varargs...)
	ret0, _ := ret[0].(*cloudpb.DeleteOrgIDEConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOrgIDEConfig indicates an expected call of DeleteOrgIDEConfig.
func (mr *MockOrganizationServiceClientMockRecorder) DeleteOrgIDEConfig(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrgIDEConfig", reflect.TypeOf((*MockOrganizationServiceClient)(nil).DeleteOrgIDEConfig), varargs...)
}

// GetOrg mocks base method.
func (m *MockOrganizationServiceClient) GetOrg(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*cloudpb.OrgInfo, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrg", varargs...)
	ret0, _ := ret[0].(*cloudpb.OrgInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrg indicates an expected call of GetOrg.
func (mr *MockOrganizationServiceClientMockRecorder) GetOrg(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrg", reflect.TypeOf((*MockOrganizationServiceClient)(nil).GetOrg), varargs...)
}

// GetOrgIDEConfigs mocks base method.
func (m *MockOrganizationServiceClient) GetOrgIDEConfigs(ctx context.Context, in *cloudpb.GetOrgIDEConfigsRequest, opts ...grpc.CallOption) (*cloudpb.GetOrgIDEConfigsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrgIDEConfigs", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetOrgIDEConfigsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrgIDEConfigs indicates an expected call of GetOrgIDEConfigs.
func (mr *MockOrganizationServiceClientMockRecorder) GetOrgIDEConfigs(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgIDEConfigs", reflect.TypeOf((*MockOrganizationServiceClient)(nil).GetOrgIDEConfigs), varargs...)
}

// GetUsersInOrg mocks base method.
func (m *MockOrganizationServiceClient) GetUsersInOrg(ctx context.Context, in *cloudpb.GetUsersInOrgRequest, opts ...grpc.CallOption) (*cloudpb.GetUsersInOrgResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUsersInOrg", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetUsersInOrgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUsersInOrg indicates an expected call of GetUsersInOrg.
func (mr *MockOrganizationServiceClientMockRecorder) GetUsersInOrg(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsersInOrg", reflect.TypeOf((*MockOrganizationServiceClient)(nil).GetUsersInOrg), varargs...)
}

// InviteUser mocks base method.
func (m *MockOrganizationServiceClient) InviteUser(ctx context.Context, in *cloudpb.InviteUserRequest, opts ...grpc.CallOption) (*cloudpb.InviteUserResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "InviteUser", varargs...)
	ret0, _ := ret[0].(*cloudpb.InviteUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InviteUser indicates an expected call of InviteUser.
func (mr *MockOrganizationServiceClientMockRecorder) InviteUser(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteUser", reflect.TypeOf((*MockOrganizationServiceClient)(nil).InviteUser), varargs...)
}

// RemoveUserFromOrg mocks base method.
func (m *MockOrganizationServiceClient) RemoveUserFromOrg(ctx context.Context, in *cloudpb.RemoveUserFromOrgRequest, opts ...grpc.CallOption) (*cloudpb.RemoveUserFromOrgResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveUserFromOrg", varargs...)
	ret0, _ := ret[0].(*cloudpb.RemoveUserFromOrgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveUserFromOrg indicates an expected call of RemoveUserFromOrg.
func (mr *MockOrganizationServiceClientMockRecorder) RemoveUserFromOrg(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveUserFromOrg", reflect.TypeOf((*MockOrganizationServiceClient)(nil).RemoveUserFromOrg), varargs...)
}

// RevokeAllInviteTokens mocks base method.
func (m *MockOrganizationServiceClient) RevokeAllInviteTokens(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*types.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevokeAllInviteTokens", varargs...)
	ret0, _ := ret[0].(*types.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeAllInviteTokens indicates an expected call of RevokeAllInviteTokens.
func (mr *MockOrganizationServiceClientMockRecorder) RevokeAllInviteTokens(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeAllInviteTokens", reflect.TypeOf((*MockOrganizationServiceClient)(nil).RevokeAllInviteTokens), varargs...)
}

// UpdateOrg mocks base method.
func (m *MockOrganizationServiceClient) UpdateOrg(ctx context.Context, in *cloudpb.UpdateOrgRequest, opts ...grpc.CallOption) (*cloudpb.OrgInfo, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateOrg", varargs...)
	ret0, _ := ret[0].(*cloudpb.OrgInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOrg indicates an expected call of UpdateOrg.
func (mr *MockOrganizationServiceClientMockRecorder) UpdateOrg(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrg", reflect.TypeOf((*MockOrganizationServiceClient)(nil).UpdateOrg), varargs...)
}

// VerifyInviteToken mocks base method.
func (m *MockOrganizationServiceClient) VerifyInviteToken(ctx context.Context, in *cloudpb.InviteToken, opts ...grpc.CallOption) (*cloudpb.VerifyInviteTokenResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyInviteToken", varargs...)
	ret0, _ := ret[0].(*cloudpb.VerifyInviteTokenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyInviteToken indicates an expected call of VerifyInviteToken.
func (mr *MockOrganizationServiceClientMockRecorder) VerifyInviteToken(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyInviteToken", reflect.TypeOf((*MockOrganizationServiceClient)(nil).VerifyInviteToken), varargs...)
}

// MockOrganizationServiceServer is a mock of OrganizationServiceServer interface.
type MockOrganizationServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockOrganizationServiceServerMockRecorder
}

// MockOrganizationServiceServerMockRecorder is the mock recorder for MockOrganizationServiceServer.
type MockOrganizationServiceServerMockRecorder struct {
	mock *MockOrganizationServiceServer
}

// NewMockOrganizationServiceServer creates a new mock instance.
func NewMockOrganizationServiceServer(ctrl *gomock.Controller) *MockOrganizationServiceServer {
	mock := &MockOrganizationServiceServer{ctrl: ctrl}
	mock.recorder = &MockOrganizationServiceServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockOrganizationServiceServer) EXPECT() *MockOrganizationServiceServerMockRecorder {
	return m.recorder
}

// AddOrgIDEConfig mocks base method.
func (m *MockOrganizationServiceServer) AddOrgIDEConfig(arg0 context.Context, arg1 *cloudpb.AddOrgIDEConfigRequest) (*cloudpb.AddOrgIDEConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOrgIDEConfig", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.AddOrgIDEConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddOrgIDEConfig indicates an expected call of AddOrgIDEConfig.
func (mr *MockOrganizationServiceServerMockRecorder) AddOrgIDEConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrgIDEConfig", reflect.TypeOf((*MockOrganizationServiceServer)(nil).AddOrgIDEConfig), arg0, arg1)
}

// CreateInviteToken mocks base method.
func (m *MockOrganizationServiceServer) CreateInviteToken(arg0 context.Context, arg1 *cloudpb.CreateInviteTokenRequest) (*cloudpb.InviteToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInviteToken", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.InviteToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateInviteToken indicates an expected call of CreateInviteToken.
func (mr *MockOrganizationServiceServerMockRecorder) CreateInviteToken(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInviteToken", reflect.TypeOf((*MockOrganizationServiceServer)(nil).CreateInviteToken), arg0, arg1)
}

// CreateOrg mocks base method.
func (m *MockOrganizationServiceServer) CreateOrg(arg0 context.Context, arg1 *cloudpb.CreateOrgRequest) (*uuidpb.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrg", arg0, arg1)
	ret0, _ := ret[0].(*uuidpb.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateOrg indicates an expected call of CreateOrg.
func (mr *MockOrganizationServiceServerMockRecorder) CreateOrg(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrg", reflect.TypeOf((*MockOrganizationServiceServer)(nil).CreateOrg), arg0, arg1)
}

// DeleteOrgIDEConfig mocks base method.
func (m *MockOrganizationServiceServer) DeleteOrgIDEConfig(arg0 context.Context, arg1 *cloudpb.DeleteOrgIDEConfigRequest) (*cloudpb.DeleteOrgIDEConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOrgIDEConfig", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.DeleteOrgIDEConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOrgIDEConfig indicates an expected call of DeleteOrgIDEConfig.
func (mr *MockOrganizationServiceServerMockRecorder) DeleteOrgIDEConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrgIDEConfig", reflect.TypeOf((*MockOrganizationServiceServer)(nil).DeleteOrgIDEConfig), arg0, arg1)
}

// GetOrg mocks base method.
func (m *MockOrganizationServiceServer) GetOrg(arg0 context.Context, arg1 *uuidpb.UUID) (*cloudpb.OrgInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrg", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.OrgInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrg indicates an expected call of GetOrg.
func (mr *MockOrganizationServiceServerMockRecorder) GetOrg(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrg", reflect.TypeOf((*MockOrganizationServiceServer)(nil).GetOrg), arg0, arg1)
}

// GetOrgIDEConfigs mocks base method.
func (m *MockOrganizationServiceServer) GetOrgIDEConfigs(arg0 context.Context, arg1 *cloudpb.GetOrgIDEConfigsRequest) (*cloudpb.GetOrgIDEConfigsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrgIDEConfigs", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetOrgIDEConfigsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrgIDEConfigs indicates an expected call of GetOrgIDEConfigs.
func (mr *MockOrganizationServiceServerMockRecorder) GetOrgIDEConfigs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgIDEConfigs", reflect.TypeOf((*MockOrganizationServiceServer)(nil).GetOrgIDEConfigs), arg0, arg1)
}

// GetUsersInOrg mocks base method.
func (m *MockOrganizationServiceServer) GetUsersInOrg(arg0 context.Context, arg1 *cloudpb.GetUsersInOrgRequest) (*cloudpb.GetUsersInOrgResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUsersInOrg", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetUsersInOrgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUsersInOrg indicates an expected call of GetUsersInOrg.
func (mr *MockOrganizationServiceServerMockRecorder) GetUsersInOrg(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsersInOrg", reflect.TypeOf((*MockOrganizationServiceServer)(nil).GetUsersInOrg), arg0, arg1)
}

// InviteUser mocks base method.
func (m *MockOrganizationServiceServer) InviteUser(arg0 context.Context, arg1 *cloudpb.InviteUserRequest) (*cloudpb.InviteUserResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InviteUser", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.InviteUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InviteUser indicates an expected call of InviteUser.
func (mr *MockOrganizationServiceServerMockRecorder) InviteUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteUser", reflect.TypeOf((*MockOrganizationServiceServer)(nil).InviteUser), arg0, arg1)
}

// RemoveUserFromOrg mocks base method.
func (m *MockOrganizationServiceServer) RemoveUserFromOrg(arg0 context.Context, arg1 *cloudpb.RemoveUserFromOrgRequest) (*cloudpb.RemoveUserFromOrgResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveUserFromOrg", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.RemoveUserFromOrgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveUserFromOrg indicates an expected call of RemoveUserFromOrg.
func (mr *MockOrganizationServiceServerMockRecorder) RemoveUserFromOrg(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveUserFromOrg", reflect.TypeOf((*MockOrganizationServiceServer)(nil).RemoveUserFromOrg), arg0, arg1)
}

// RevokeAllInviteTokens mocks base method.
func (m *MockOrganizationServiceServer) RevokeAllInviteTokens(arg0 context.Context, arg1 *uuidpb.UUID) (*types.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeAllInviteTokens", arg0, arg1)
	ret0, _ := ret[0].(*types.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeAllInviteTokens indicates an expected call of RevokeAllInviteTokens.
func (mr *MockOrganizationServiceServerMockRecorder) RevokeAllInviteTokens(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeAllInviteTokens", reflect.TypeOf((*MockOrganizationServiceServer)(nil).RevokeAllInviteTokens), arg0, arg1)
}

// UpdateOrg mocks base method.
func (m *MockOrganizationServiceServer) UpdateOrg(arg0 context.Context, arg1 *cloudpb.UpdateOrgRequest) (*cloudpb.OrgInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOrg", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.OrgInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOrg indicates an expected call of UpdateOrg.
func (mr *MockOrganizationServiceServerMockRecorder) UpdateOrg(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrg", reflect.TypeOf((*MockOrganizationServiceServer)(nil).UpdateOrg), arg0, arg1)
}

// VerifyInviteToken mocks base method.
func (m *MockOrganizationServiceServer) VerifyInviteToken(arg0 context.Context, arg1 *cloudpb.InviteToken) (*cloudpb.VerifyInviteTokenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyInviteToken", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.VerifyInviteTokenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyInviteToken indicates an expected call of VerifyInviteToken.
func (mr *MockOrganizationServiceServerMockRecorder) VerifyInviteToken(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyInviteToken", reflect.TypeOf((*MockOrganizationServiceServer)(nil).VerifyInviteToken), arg0, arg1)
}

// MockAuthServiceClient is a mock of AuthServiceClient interface.
type MockAuthServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockAuthServiceClientMockRecorder
}

// MockAuthServiceClientMockRecorder is the mock recorder for MockAuthServiceClient.
type MockAuthServiceClientMockRecorder struct {
	mock *MockAuthServiceClient
}

// NewMockAuthServiceClient creates a new mock instance.
func NewMockAuthServiceClient(ctrl *gomock.Controller) *MockAuthServiceClient {
	mock := &MockAuthServiceClient{ctrl: ctrl}
	mock.recorder = &MockAuthServiceClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthServiceClient) EXPECT() *MockAuthServiceClientMockRecorder {
	return m.recorder
}

// Login mocks base method.
func (m *MockAuthServiceClient) Login(ctx context.Context, in *cloudpb.LoginRequest, opts ...grpc.CallOption) (*cloudpb.LoginReply, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Login", varargs...)
	ret0, _ := ret[0].(*cloudpb.LoginReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Login indicates an expected call of Login.
func (mr *MockAuthServiceClientMockRecorder) Login(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockAuthServiceClient)(nil).Login), varargs...)
}

// MockAuthServiceServer is a mock of AuthServiceServer interface.
type MockAuthServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockAuthServiceServerMockRecorder
}

// MockAuthServiceServerMockRecorder is the mock recorder for MockAuthServiceServer.
type MockAuthServiceServerMockRecorder struct {
	mock *MockAuthServiceServer
}

// NewMockAuthServiceServer creates a new mock instance.
func NewMockAuthServiceServer(ctrl *gomock.Controller) *MockAuthServiceServer {
	mock := &MockAuthServiceServer{ctrl: ctrl}
	mock.recorder = &MockAuthServiceServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthServiceServer) EXPECT() *MockAuthServiceServerMockRecorder {
	return m.recorder
}

// Login mocks base method.
func (m *MockAuthServiceServer) Login(arg0 context.Context, arg1 *cloudpb.LoginRequest) (*cloudpb.LoginReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Login", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.LoginReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Login indicates an expected call of Login.
func (mr *MockAuthServiceServerMockRecorder) Login(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockAuthServiceServer)(nil).Login), arg0, arg1)
}

// MockVizierImageAuthorizationClient is a mock of VizierImageAuthorizationClient interface.
type MockVizierImageAuthorizationClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierImageAuthorizationClientMockRecorder
}

// MockVizierImageAuthorizationClientMockRecorder is the mock recorder for MockVizierImageAuthorizationClient.
type MockVizierImageAuthorizationClientMockRecorder struct {
	mock *MockVizierImageAuthorizationClient
}

// NewMockVizierImageAuthorizationClient creates a new mock instance.
func NewMockVizierImageAuthorizationClient(ctrl *gomock.Controller) *MockVizierImageAuthorizationClient {
	mock := &MockVizierImageAuthorizationClient{ctrl: ctrl}
	mock.recorder = &MockVizierImageAuthorizationClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierImageAuthorizationClient) EXPECT() *MockVizierImageAuthorizationClientMockRecorder {
	return m.recorder
}

// GetImageCredentials mocks base method.
func (m *MockVizierImageAuthorizationClient) GetImageCredentials(ctx context.Context, in *cloudpb.GetImageCredentialsRequest, opts ...grpc.CallOption) (*cloudpb.GetImageCredentialsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetImageCredentials", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetImageCredentialsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageCredentials indicates an expected call of GetImageCredentials.
func (mr *MockVizierImageAuthorizationClientMockRecorder) GetImageCredentials(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageCredentials", reflect.TypeOf((*MockVizierImageAuthorizationClient)(nil).GetImageCredentials), varargs...)
}

// MockVizierImageAuthorizationServer is a mock of VizierImageAuthorizationServer interface.
type MockVizierImageAuthorizationServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierImageAuthorizationServerMockRecorder
}

// MockVizierImageAuthorizationServerMockRecorder is the mock recorder for MockVizierImageAuthorizationServer.
type MockVizierImageAuthorizationServerMockRecorder struct {
	mock *MockVizierImageAuthorizationServer
}

// NewMockVizierImageAuthorizationServer creates a new mock instance.
func NewMockVizierImageAuthorizationServer(ctrl *gomock.Controller) *MockVizierImageAuthorizationServer {
	mock := &MockVizierImageAuthorizationServer{ctrl: ctrl}
	mock.recorder = &MockVizierImageAuthorizationServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierImageAuthorizationServer) EXPECT() *MockVizierImageAuthorizationServerMockRecorder {
	return m.recorder
}

// GetImageCredentials mocks base method.
func (m *MockVizierImageAuthorizationServer) GetImageCredentials(arg0 context.Context, arg1 *cloudpb.GetImageCredentialsRequest) (*cloudpb.GetImageCredentialsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImageCredentials", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetImageCredentialsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageCredentials indicates an expected call of GetImageCredentials.
func (mr *MockVizierImageAuthorizationServerMockRecorder) GetImageCredentials(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageCredentials", reflect.TypeOf((*MockVizierImageAuthorizationServer)(nil).GetImageCredentials), arg0, arg1)
}

// MockArtifactTrackerClient is a mock of ArtifactTrackerClient interface.
type MockArtifactTrackerClient struct {
	ctrl     *gomock.Controller
	recorder *MockArtifactTrackerClientMockRecorder
}

// MockArtifactTrackerClientMockRecorder is the mock recorder for MockArtifactTrackerClient.
type MockArtifactTrackerClientMockRecorder struct {
	mock *MockArtifactTrackerClient
}

// NewMockArtifactTrackerClient creates a new mock instance.
func NewMockArtifactTrackerClient(ctrl *gomock.Controller) *MockArtifactTrackerClient {
	mock := &MockArtifactTrackerClient{ctrl: ctrl}
	mock.recorder = &MockArtifactTrackerClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockArtifactTrackerClient) EXPECT() *MockArtifactTrackerClientMockRecorder {
	return m.recorder
}

// GetArtifactList mocks base method.
func (m *MockArtifactTrackerClient) GetArtifactList(ctx context.Context, in *cloudpb.GetArtifactListRequest, opts ...grpc.CallOption) (*cloudpb.ArtifactSet, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetArtifactList", varargs...)
	ret0, _ := ret[0].(*cloudpb.ArtifactSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArtifactList indicates an expected call of GetArtifactList.
func (mr *MockArtifactTrackerClientMockRecorder) GetArtifactList(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifactList", reflect.TypeOf((*MockArtifactTrackerClient)(nil).GetArtifactList), varargs...)
}

// GetDownloadLink mocks base method.
func (m *MockArtifactTrackerClient) GetDownloadLink(ctx context.Context, in *cloudpb.GetDownloadLinkRequest, opts ...grpc.CallOption) (*cloudpb.GetDownloadLinkResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDownloadLink", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetDownloadLinkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDownloadLink indicates an expected call of GetDownloadLink.
func (mr *MockArtifactTrackerClientMockRecorder) GetDownloadLink(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDownloadLink", reflect.TypeOf((*MockArtifactTrackerClient)(nil).GetDownloadLink), varargs...)
}

// MockArtifactTrackerServer is a mock of ArtifactTrackerServer interface.
type MockArtifactTrackerServer struct {
	ctrl     *gomock.Controller
	recorder *MockArtifactTrackerServerMockRecorder
}

// MockArtifactTrackerServerMockRecorder is the mock recorder for MockArtifactTrackerServer.
type MockArtifactTrackerServerMockRecorder struct {
	mock *MockArtifactTrackerServer
}

// NewMockArtifactTrackerServer creates a new mock instance.
func NewMockArtifactTrackerServer(ctrl *gomock.Controller) *MockArtifactTrackerServer {
	mock := &MockArtifactTrackerServer{ctrl: ctrl}
	mock.recorder = &MockArtifactTrackerServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockArtifactTrackerServer) EXPECT() *MockArtifactTrackerServerMockRecorder {
	return m.recorder
}

// GetArtifactList mocks base method.
func (m *MockArtifactTrackerServer) GetArtifactList(arg0 context.Context, arg1 *cloudpb.GetArtifactListRequest) (*cloudpb.ArtifactSet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArtifactList", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.ArtifactSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArtifactList indicates an expected call of GetArtifactList.
func (mr *MockArtifactTrackerServerMockRecorder) GetArtifactList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifactList", reflect.TypeOf((*MockArtifactTrackerServer)(nil).GetArtifactList), arg0, arg1)
}

// GetDownloadLink mocks base method.
func (m *MockArtifactTrackerServer) GetDownloadLink(arg0 context.Context, arg1 *cloudpb.GetDownloadLinkRequest) (*cloudpb.GetDownloadLinkResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDownloadLink", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetDownloadLinkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDownloadLink indicates an expected call of GetDownloadLink.
func (mr *MockArtifactTrackerServerMockRecorder) GetDownloadLink(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDownloadLink", reflect.TypeOf((*MockArtifactTrackerServer)(nil).GetDownloadLink), arg0, arg1)
}

// MockVizierClusterInfoClient is a mock of VizierClusterInfoClient interface.
type MockVizierClusterInfoClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierClusterInfoClientMockRecorder
}

// MockVizierClusterInfoClientMockRecorder is the mock recorder for MockVizierClusterInfoClient.
type MockVizierClusterInfoClientMockRecorder struct {
	mock *MockVizierClusterInfoClient
}

// NewMockVizierClusterInfoClient creates a new mock instance.
func NewMockVizierClusterInfoClient(ctrl *gomock.Controller) *MockVizierClusterInfoClient {
	mock := &MockVizierClusterInfoClient{ctrl: ctrl}
	mock.recorder = &MockVizierClusterInfoClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierClusterInfoClient) EXPECT() *MockVizierClusterInfoClientMockRecorder {
	return m.recorder
}

// CreateCluster mocks base method.
func (m *MockVizierClusterInfoClient) CreateCluster(ctx context.Context, in *cloudpb.CreateClusterRequest, opts ...grpc.CallOption) (*cloudpb.CreateClusterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCluster", varargs...)
	ret0, _ := ret[0].(*cloudpb.CreateClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCluster indicates an expected call of CreateCluster.
func (mr *MockVizierClusterInfoClientMockRecorder) CreateCluster(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockVizierClusterInfoClient)(nil).CreateCluster), varargs...)
}

// GetClusterConnectionInfo mocks base method.
func (m *MockVizierClusterInfoClient) GetClusterConnectionInfo(ctx context.Context, in *cloudpb.GetClusterConnectionInfoRequest, opts ...grpc.CallOption) (*cloudpb.GetClusterConnectionInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterConnectionInfo", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetClusterConnectionInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterConnectionInfo indicates an expected call of GetClusterConnectionInfo.
func (mr *MockVizierClusterInfoClientMockRecorder) GetClusterConnectionInfo(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterConnectionInfo", reflect.TypeOf((*MockVizierClusterInfoClient)(nil).GetClusterConnectionInfo), varargs...)
}

// GetClusterInfo mocks base method.
func (m *MockVizierClusterInfoClient) GetClusterInfo(ctx context.Context, in *cloudpb.GetClusterInfoRequest, opts ...grpc.CallOption) (*cloudpb.GetClusterInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterInfo", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetClusterInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterInfo indicates an expected call of GetClusterInfo.
func (mr *MockVizierClusterInfoClientMockRecorder) GetClusterInfo(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterInfo", reflect.TypeOf((*MockVizierClusterInfoClient)(nil).GetClusterInfo), varargs...)
}

// UpdateClusterVizierConfig mocks base method.
func (m *MockVizierClusterInfoClient) UpdateClusterVizierConfig(ctx context.Context, in *cloudpb.UpdateClusterVizierConfigRequest, opts ...grpc.CallOption) (*cloudpb.UpdateClusterVizierConfigResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateClusterVizierConfig", varargs...)
	ret0, _ := ret[0].(*cloudpb.UpdateClusterVizierConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterVizierConfig indicates an expected call of UpdateClusterVizierConfig.
func (mr *MockVizierClusterInfoClientMockRecorder) UpdateClusterVizierConfig(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterVizierConfig", reflect.TypeOf((*MockVizierClusterInfoClient)(nil).UpdateClusterVizierConfig), varargs...)
}

// UpdateOrInstallCluster mocks base method.
func (m *MockVizierClusterInfoClient) UpdateOrInstallCluster(ctx context.Context, in *cloudpb.UpdateOrInstallClusterRequest, opts ...grpc.CallOption) (*cloudpb.UpdateOrInstallClusterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateOrInstallCluster", varargs...)
	ret0, _ := ret[0].(*cloudpb.UpdateOrInstallClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOrInstallCluster indicates an expected call of UpdateOrInstallCluster.
func (mr *MockVizierClusterInfoClientMockRecorder) UpdateOrInstallCluster(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrInstallCluster", reflect.TypeOf((*MockVizierClusterInfoClient)(nil).UpdateOrInstallCluster), varargs...)
}

// MockVizierClusterInfoServer is a mock of VizierClusterInfoServer interface.
type MockVizierClusterInfoServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierClusterInfoServerMockRecorder
}

// MockVizierClusterInfoServerMockRecorder is the mock recorder for MockVizierClusterInfoServer.
type MockVizierClusterInfoServerMockRecorder struct {
	mock *MockVizierClusterInfoServer
}

// NewMockVizierClusterInfoServer creates a new mock instance.
func NewMockVizierClusterInfoServer(ctrl *gomock.Controller) *MockVizierClusterInfoServer {
	mock := &MockVizierClusterInfoServer{ctrl: ctrl}
	mock.recorder = &MockVizierClusterInfoServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierClusterInfoServer) EXPECT() *MockVizierClusterInfoServerMockRecorder {
	return m.recorder
}

// CreateCluster mocks base method.
func (m *MockVizierClusterInfoServer) CreateCluster(arg0 context.Context, arg1 *cloudpb.CreateClusterRequest) (*cloudpb.CreateClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCluster", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.CreateClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCluster indicates an expected call of CreateCluster.
func (mr *MockVizierClusterInfoServerMockRecorder) CreateCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockVizierClusterInfoServer)(nil).CreateCluster), arg0, arg1)
}

// GetClusterConnectionInfo mocks base method.
func (m *MockVizierClusterInfoServer) GetClusterConnectionInfo(arg0 context.Context, arg1 *cloudpb.GetClusterConnectionInfoRequest) (*cloudpb.GetClusterConnectionInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterConnectionInfo", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetClusterConnectionInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterConnectionInfo indicates an expected call of GetClusterConnectionInfo.
func (mr *MockVizierClusterInfoServerMockRecorder) GetClusterConnectionInfo(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterConnectionInfo", reflect.TypeOf((*MockVizierClusterInfoServer)(nil).GetClusterConnectionInfo), arg0, arg1)
}

// GetClusterInfo mocks base method.
func (m *MockVizierClusterInfoServer) GetClusterInfo(arg0 context.Context, arg1 *cloudpb.GetClusterInfoRequest) (*cloudpb.GetClusterInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterInfo", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetClusterInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterInfo indicates an expected call of GetClusterInfo.
func (mr *MockVizierClusterInfoServerMockRecorder) GetClusterInfo(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterInfo", reflect.TypeOf((*MockVizierClusterInfoServer)(nil).GetClusterInfo), arg0, arg1)
}

// UpdateClusterVizierConfig mocks base method.
func (m *MockVizierClusterInfoServer) UpdateClusterVizierConfig(arg0 context.Context, arg1 *cloudpb.UpdateClusterVizierConfigRequest) (*cloudpb.UpdateClusterVizierConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterVizierConfig", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.UpdateClusterVizierConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterVizierConfig indicates an expected call of UpdateClusterVizierConfig.
func (mr *MockVizierClusterInfoServerMockRecorder) UpdateClusterVizierConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterVizierConfig", reflect.TypeOf((*MockVizierClusterInfoServer)(nil).UpdateClusterVizierConfig), arg0, arg1)
}

// UpdateOrInstallCluster mocks base method.
func (m *MockVizierClusterInfoServer) UpdateOrInstallCluster(arg0 context.Context, arg1 *cloudpb.UpdateOrInstallClusterRequest) (*cloudpb.UpdateOrInstallClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOrInstallCluster", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.UpdateOrInstallClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOrInstallCluster indicates an expected call of UpdateOrInstallCluster.
func (mr *MockVizierClusterInfoServerMockRecorder) UpdateOrInstallCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrInstallCluster", reflect.TypeOf((*MockVizierClusterInfoServer)(nil).UpdateOrInstallCluster), arg0, arg1)
}

// MockVizierDeploymentKeyManagerClient is a mock of VizierDeploymentKeyManagerClient interface.
type MockVizierDeploymentKeyManagerClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierDeploymentKeyManagerClientMockRecorder
}

// MockVizierDeploymentKeyManagerClientMockRecorder is the mock recorder for MockVizierDeploymentKeyManagerClient.
type MockVizierDeploymentKeyManagerClientMockRecorder struct {
	mock *MockVizierDeploymentKeyManagerClient
}

// NewMockVizierDeploymentKeyManagerClient creates a new mock instance.
func NewMockVizierDeploymentKeyManagerClient(ctrl *gomock.Controller) *MockVizierDeploymentKeyManagerClient {
	mock := &MockVizierDeploymentKeyManagerClient{ctrl: ctrl}
	mock.recorder = &MockVizierDeploymentKeyManagerClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierDeploymentKeyManagerClient) EXPECT() *MockVizierDeploymentKeyManagerClientMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockVizierDeploymentKeyManagerClient) Create(ctx context.Context, in *cloudpb.CreateDeploymentKeyRequest, opts ...grpc.CallOption) (*cloudpb.DeploymentKey, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Create", varargs...)
	ret0, _ := ret[0].(*cloudpb.DeploymentKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockVizierDeploymentKeyManagerClientMockRecorder) Create(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockVizierDeploymentKeyManagerClient)(nil).Create), varargs...)
}

// Delete mocks base method.
func (m *MockVizierDeploymentKeyManagerClient) Delete(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*types.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(*types.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockVizierDeploymentKeyManagerClientMockRecorder) Delete(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockVizierDeploymentKeyManagerClient)(nil).Delete), varargs...)
}

// Get mocks base method.
func (m *MockVizierDeploymentKeyManagerClient) Get(ctx context.Context, in *cloudpb.GetDeploymentKeyRequest, opts ...grpc.CallOption) (*cloudpb.GetDeploymentKeyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetDeploymentKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockVizierDeploymentKeyManagerClientMockRecorder) Get(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockVizierDeploymentKeyManagerClient)(nil).Get), varargs...)
}

// List mocks base method.
func (m *MockVizierDeploymentKeyManagerClient) List(ctx context.Context, in *cloudpb.ListDeploymentKeyRequest, opts ...grpc.CallOption) (*cloudpb.ListDeploymentKeyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].(*cloudpb.ListDeploymentKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockVizierDeploymentKeyManagerClientMockRecorder) List(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockVizierDeploymentKeyManagerClient)(nil).List), varargs...)
}

// LookupDeploymentKey mocks base method.
func (m *MockVizierDeploymentKeyManagerClient) LookupDeploymentKey(ctx context.Context, in *cloudpb.LookupDeploymentKeyRequest, opts ...grpc.CallOption) (*cloudpb.LookupDeploymentKeyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LookupDeploymentKey", varargs...)
	ret0, _ := ret[0].(*cloudpb.LookupDeploymentKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupDeploymentKey indicates an expected call of LookupDeploymentKey.
func (mr *MockVizierDeploymentKeyManagerClientMockRecorder) LookupDeploymentKey(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupDeploymentKey", reflect.TypeOf((*MockVizierDeploymentKeyManagerClient)(nil).LookupDeploymentKey), varargs...)
}

// MockVizierDeploymentKeyManagerServer is a mock of VizierDeploymentKeyManagerServer interface.
type MockVizierDeploymentKeyManagerServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierDeploymentKeyManagerServerMockRecorder
}

// MockVizierDeploymentKeyManagerServerMockRecorder is the mock recorder for MockVizierDeploymentKeyManagerServer.
type MockVizierDeploymentKeyManagerServerMockRecorder struct {
	mock *MockVizierDeploymentKeyManagerServer
}

// NewMockVizierDeploymentKeyManagerServer creates a new mock instance.
func NewMockVizierDeploymentKeyManagerServer(ctrl *gomock.Controller) *MockVizierDeploymentKeyManagerServer {
	mock := &MockVizierDeploymentKeyManagerServer{ctrl: ctrl}
	mock.recorder = &MockVizierDeploymentKeyManagerServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierDeploymentKeyManagerServer) EXPECT() *MockVizierDeploymentKeyManagerServerMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockVizierDeploymentKeyManagerServer) Create(arg0 context.Context, arg1 *cloudpb.CreateDeploymentKeyRequest) (*cloudpb.DeploymentKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.DeploymentKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockVizierDeploymentKeyManagerServerMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockVizierDeploymentKeyManagerServer)(nil).Create), arg0, arg1)
}

// Delete mocks base method.
func (m *MockVizierDeploymentKeyManagerServer) Delete(arg0 context.Context, arg1 *uuidpb.UUID) (*types.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(*types.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockVizierDeploymentKeyManagerServerMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockVizierDeploymentKeyManagerServer)(nil).Delete), arg0, arg1)
}

// Get mocks base method.
func (m *MockVizierDeploymentKeyManagerServer) Get(arg0 context.Context, arg1 *cloudpb.GetDeploymentKeyRequest) (*cloudpb.GetDeploymentKeyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetDeploymentKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockVizierDeploymentKeyManagerServerMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockVizierDeploymentKeyManagerServer)(nil).Get), arg0, arg1)
}

// List mocks base method.
func (m *MockVizierDeploymentKeyManagerServer) List(arg0 context.Context, arg1 *cloudpb.ListDeploymentKeyRequest) (*cloudpb.ListDeploymentKeyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.ListDeploymentKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockVizierDeploymentKeyManagerServerMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockVizierDeploymentKeyManagerServer)(nil).List), arg0, arg1)
}

// LookupDeploymentKey mocks base method.
func (m *MockVizierDeploymentKeyManagerServer) LookupDeploymentKey(arg0 context.Context, arg1 *cloudpb.LookupDeploymentKeyRequest) (*cloudpb.LookupDeploymentKeyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupDeploymentKey", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.LookupDeploymentKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupDeploymentKey indicates an expected call of LookupDeploymentKey.
func (mr *MockVizierDeploymentKeyManagerServerMockRecorder) LookupDeploymentKey(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupDeploymentKey", reflect.TypeOf((*MockVizierDeploymentKeyManagerServer)(nil).LookupDeploymentKey), arg0, arg1)
}

// MockAPIKeyManagerClient is a mock of APIKeyManagerClient interface.
type MockAPIKeyManagerClient struct {
	ctrl     *gomock.Controller
	recorder *MockAPIKeyManagerClientMockRecorder
}

// MockAPIKeyManagerClientMockRecorder is the mock recorder for MockAPIKeyManagerClient.
type MockAPIKeyManagerClientMockRecorder struct {
	mock *MockAPIKeyManagerClient
}

// NewMockAPIKeyManagerClient creates a new mock instance.
func NewMockAPIKeyManagerClient(ctrl *gomock.Controller) *MockAPIKeyManagerClient {
	mock := &MockAPIKeyManagerClient{ctrl: ctrl}
	mock.recorder = &MockAPIKeyManagerClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAPIKeyManagerClient) EXPECT() *MockAPIKeyManagerClientMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockAPIKeyManagerClient) Create(ctx context.Context, in *cloudpb.CreateAPIKeyRequest, opts ...grpc.CallOption) (*cloudpb.APIKey, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Create", varargs...)
	ret0, _ := ret[0].(*cloudpb.APIKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockAPIKeyManagerClientMockRecorder) Create(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockAPIKeyManagerClient)(nil).Create), varargs...)
}

// Delete mocks base method.
func (m *MockAPIKeyManagerClient) Delete(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*types.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(*types.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockAPIKeyManagerClientMockRecorder) Delete(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockAPIKeyManagerClient)(nil).Delete), varargs...)
}

// Get mocks base method.
func (m *MockAPIKeyManagerClient) Get(ctx context.Context, in *cloudpb.GetAPIKeyRequest, opts ...grpc.CallOption) (*cloudpb.GetAPIKeyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetAPIKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockAPIKeyManagerClientMockRecorder) Get(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAPIKeyManagerClient)(nil).Get), varargs...)
}

// List mocks base method.
func (m *MockAPIKeyManagerClient) List(ctx context.Context, in *cloudpb.ListAPIKeyRequest, opts ...grpc.CallOption) (*cloudpb.ListAPIKeyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].(*cloudpb.ListAPIKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockAPIKeyManagerClientMockRecorder) List(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockAPIKeyManagerClient)(nil).List), varargs...)
}

// LookupAPIKey mocks base method.
func (m *MockAPIKeyManagerClient) LookupAPIKey(ctx context.Context, in *cloudpb.LookupAPIKeyRequest, opts ...grpc.CallOption) (*cloudpb.LookupAPIKeyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LookupAPIKey", varargs...)
	ret0, _ := ret[0].(*cloudpb.LookupAPIKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupAPIKey indicates an expected call of LookupAPIKey.
func (mr *MockAPIKeyManagerClientMockRecorder) LookupAPIKey(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupAPIKey", reflect.TypeOf((*MockAPIKeyManagerClient)(nil).LookupAPIKey), varargs...)
}

// MockAPIKeyManagerServer is a mock of APIKeyManagerServer interface.
type MockAPIKeyManagerServer struct {
	ctrl     *gomock.Controller
	recorder *MockAPIKeyManagerServerMockRecorder
}

// MockAPIKeyManagerServerMockRecorder is the mock recorder for MockAPIKeyManagerServer.
type MockAPIKeyManagerServerMockRecorder struct {
	mock *MockAPIKeyManagerServer
}

// NewMockAPIKeyManagerServer creates a new mock instance.
func NewMockAPIKeyManagerServer(ctrl *gomock.Controller) *MockAPIKeyManagerServer {
	mock := &MockAPIKeyManagerServer{ctrl: ctrl}
	mock.recorder = &MockAPIKeyManagerServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAPIKeyManagerServer) EXPECT() *MockAPIKeyManagerServerMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockAPIKeyManagerServer) Create(arg0 context.Context, arg1 *cloudpb.CreateAPIKeyRequest) (*cloudpb.APIKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.APIKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockAPIKeyManagerServerMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockAPIKeyManagerServer)(nil).Create), arg0, arg1)
}

// Delete mocks base method.
func (m *MockAPIKeyManagerServer) Delete(arg0 context.Context, arg1 *uuidpb.UUID) (*types.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(*types.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockAPIKeyManagerServerMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockAPIKeyManagerServer)(nil).Delete), arg0, arg1)
}

// Get mocks base method.
func (m *MockAPIKeyManagerServer) Get(arg0 context.Context, arg1 *cloudpb.GetAPIKeyRequest) (*cloudpb.GetAPIKeyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetAPIKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockAPIKeyManagerServerMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAPIKeyManagerServer)(nil).Get), arg0, arg1)
}

// List mocks base method.
func (m *MockAPIKeyManagerServer) List(arg0 context.Context, arg1 *cloudpb.ListAPIKeyRequest) (*cloudpb.ListAPIKeyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.ListAPIKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockAPIKeyManagerServerMockRecorder) List(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockAPIKeyManagerServer)(nil).List), arg0, arg1)
}

// LookupAPIKey mocks base method.
func (m *MockAPIKeyManagerServer) LookupAPIKey(arg0 context.Context, arg1 *cloudpb.LookupAPIKeyRequest) (*cloudpb.LookupAPIKeyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupAPIKey", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.LookupAPIKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupAPIKey indicates an expected call of LookupAPIKey.
func (mr *MockAPIKeyManagerServerMockRecorder) LookupAPIKey(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupAPIKey", reflect.TypeOf((*MockAPIKeyManagerServer)(nil).LookupAPIKey), arg0, arg1)
}

// MockScriptMgrClient is a mock of ScriptMgrClient interface.
type MockScriptMgrClient struct {
	ctrl     *gomock.Controller
	recorder *MockScriptMgrClientMockRecorder
}

// MockScriptMgrClientMockRecorder is the mock recorder for MockScriptMgrClient.
type MockScriptMgrClientMockRecorder struct {
	mock *MockScriptMgrClient
}

// NewMockScriptMgrClient creates a new mock instance.
func NewMockScriptMgrClient(ctrl *gomock.Controller) *MockScriptMgrClient {
	mock := &MockScriptMgrClient{ctrl: ctrl}
	mock.recorder = &MockScriptMgrClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockScriptMgrClient) EXPECT() *MockScriptMgrClientMockRecorder {
	return m.recorder
}

// GetLiveViewContents mocks base method.
func (m *MockScriptMgrClient) GetLiveViewContents(ctx context.Context, in *cloudpb.GetLiveViewContentsReq, opts ...grpc.CallOption) (*cloudpb.GetLiveViewContentsResp, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLiveViewContents", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetLiveViewContentsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLiveViewContents indicates an expected call of GetLiveViewContents.
func (mr *MockScriptMgrClientMockRecorder) GetLiveViewContents(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLiveViewContents", reflect.TypeOf((*MockScriptMgrClient)(nil).GetLiveViewContents), varargs...)
}

// GetLiveViews mocks base method.
func (m *MockScriptMgrClient) GetLiveViews(ctx context.Context, in *cloudpb.GetLiveViewsReq, opts ...grpc.CallOption) (*cloudpb.GetLiveViewsResp, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLiveViews", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetLiveViewsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLiveViews indicates an expected call of GetLiveViews.
func (mr *MockScriptMgrClientMockRecorder) GetLiveViews(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLiveViews", reflect.TypeOf((*MockScriptMgrClient)(nil).GetLiveViews), varargs...)
}

// GetScriptContents mocks base method.
func (m *MockScriptMgrClient) GetScriptContents(ctx context.Context, in *cloudpb.GetScriptContentsReq, opts ...grpc.CallOption) (*cloudpb.GetScriptContentsResp, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetScriptContents", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetScriptContentsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetScriptContents indicates an expected call of GetScriptContents.
func (mr *MockScriptMgrClientMockRecorder) GetScriptContents(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScriptContents", reflect.TypeOf((*MockScriptMgrClient)(nil).GetScriptContents), varargs...)
}

// GetScripts mocks base method.
func (m *MockScriptMgrClient) GetScripts(ctx context.Context, in *cloudpb.GetScriptsReq, opts ...grpc.CallOption) (*cloudpb.GetScriptsResp, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetScripts", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetScriptsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetScripts indicates an expected call of GetScripts.
func (mr *MockScriptMgrClientMockRecorder) GetScripts(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScripts", reflect.TypeOf((*MockScriptMgrClient)(nil).GetScripts), varargs...)
}

// MockScriptMgrServer is a mock of ScriptMgrServer interface.
type MockScriptMgrServer struct {
	ctrl     *gomock.Controller
	recorder *MockScriptMgrServerMockRecorder
}

// MockScriptMgrServerMockRecorder is the mock recorder for MockScriptMgrServer.
type MockScriptMgrServerMockRecorder struct {
	mock *MockScriptMgrServer
}

// NewMockScriptMgrServer creates a new mock instance.
func NewMockScriptMgrServer(ctrl *gomock.Controller) *MockScriptMgrServer {
	mock := &MockScriptMgrServer{ctrl: ctrl}
	mock.recorder = &MockScriptMgrServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockScriptMgrServer) EXPECT() *MockScriptMgrServerMockRecorder {
	return m.recorder
}

// GetLiveViewContents mocks base method.
func (m *MockScriptMgrServer) GetLiveViewContents(arg0 context.Context, arg1 *cloudpb.GetLiveViewContentsReq) (*cloudpb.GetLiveViewContentsResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLiveViewContents", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetLiveViewContentsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLiveViewContents indicates an expected call of GetLiveViewContents.
func (mr *MockScriptMgrServerMockRecorder) GetLiveViewContents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLiveViewContents", reflect.TypeOf((*MockScriptMgrServer)(nil).GetLiveViewContents), arg0, arg1)
}

// GetLiveViews mocks base method.
func (m *MockScriptMgrServer) GetLiveViews(arg0 context.Context, arg1 *cloudpb.GetLiveViewsReq) (*cloudpb.GetLiveViewsResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLiveViews", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetLiveViewsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLiveViews indicates an expected call of GetLiveViews.
func (mr *MockScriptMgrServerMockRecorder) GetLiveViews(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLiveViews", reflect.TypeOf((*MockScriptMgrServer)(nil).GetLiveViews), arg0, arg1)
}

// GetScriptContents mocks base method.
func (m *MockScriptMgrServer) GetScriptContents(arg0 context.Context, arg1 *cloudpb.GetScriptContentsReq) (*cloudpb.GetScriptContentsResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScriptContents", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetScriptContentsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetScriptContents indicates an expected call of GetScriptContents.
func (mr *MockScriptMgrServerMockRecorder) GetScriptContents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScriptContents", reflect.TypeOf((*MockScriptMgrServer)(nil).GetScriptContents), arg0, arg1)
}

// GetScripts mocks base method.
func (m *MockScriptMgrServer) GetScripts(arg0 context.Context, arg1 *cloudpb.GetScriptsReq) (*cloudpb.GetScriptsResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScripts", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetScriptsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetScripts indicates an expected call of GetScripts.
func (mr *MockScriptMgrServerMockRecorder) GetScripts(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScripts", reflect.TypeOf((*MockScriptMgrServer)(nil).GetScripts), arg0, arg1)
}

// MockAutocompleteServiceClient is a mock of AutocompleteServiceClient interface.
type MockAutocompleteServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockAutocompleteServiceClientMockRecorder
}

// MockAutocompleteServiceClientMockRecorder is the mock recorder for MockAutocompleteServiceClient.
type MockAutocompleteServiceClientMockRecorder struct {
	mock *MockAutocompleteServiceClient
}

// NewMockAutocompleteServiceClient creates a new mock instance.
func NewMockAutocompleteServiceClient(ctrl *gomock.Controller) *MockAutocompleteServiceClient {
	mock := &MockAutocompleteServiceClient{ctrl: ctrl}
	mock.recorder = &MockAutocompleteServiceClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAutocompleteServiceClient) EXPECT() *MockAutocompleteServiceClientMockRecorder {
	return m.recorder
}

// Autocomplete mocks base method.
func (m *MockAutocompleteServiceClient) Autocomplete(ctx context.Context, in *cloudpb.AutocompleteRequest, opts ...grpc.CallOption) (*cloudpb.AutocompleteResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Autocomplete", varargs...)
	ret0, _ := ret[0].(*cloudpb.AutocompleteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Autocomplete indicates an expected call of Autocomplete.
func (mr *MockAutocompleteServiceClientMockRecorder) Autocomplete(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Autocomplete", reflect.TypeOf((*MockAutocompleteServiceClient)(nil).Autocomplete), varargs...)
}

// AutocompleteField mocks base method.
func (m *MockAutocompleteServiceClient) AutocompleteField(ctx context.Context, in *cloudpb.AutocompleteFieldRequest, opts ...grpc.CallOption) (*cloudpb.AutocompleteFieldResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AutocompleteField", varargs...)
	ret0, _ := ret[0].(*cloudpb.AutocompleteFieldResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AutocompleteField indicates an expected call of AutocompleteField.
func (mr *MockAutocompleteServiceClientMockRecorder) AutocompleteField(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutocompleteField", reflect.TypeOf((*MockAutocompleteServiceClient)(nil).AutocompleteField), varargs...)
}

// MockAutocompleteServiceServer is a mock of AutocompleteServiceServer interface.
type MockAutocompleteServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockAutocompleteServiceServerMockRecorder
}

// MockAutocompleteServiceServerMockRecorder is the mock recorder for MockAutocompleteServiceServer.
type MockAutocompleteServiceServerMockRecorder struct {
	mock *MockAutocompleteServiceServer
}

// NewMockAutocompleteServiceServer creates a new mock instance.
func NewMockAutocompleteServiceServer(ctrl *gomock.Controller) *MockAutocompleteServiceServer {
	mock := &MockAutocompleteServiceServer{ctrl: ctrl}
	mock.recorder = &MockAutocompleteServiceServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAutocompleteServiceServer) EXPECT() *MockAutocompleteServiceServerMockRecorder {
	return m.recorder
}

// Autocomplete mocks base method.
func (m *MockAutocompleteServiceServer) Autocomplete(arg0 context.Context, arg1 *cloudpb.AutocompleteRequest) (*cloudpb.AutocompleteResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Autocomplete", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.AutocompleteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Autocomplete indicates an expected call of Autocomplete.
func (mr *MockAutocompleteServiceServerMockRecorder) Autocomplete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Autocomplete", reflect.TypeOf((*MockAutocompleteServiceServer)(nil).Autocomplete), arg0, arg1)
}

// AutocompleteField mocks base method.
func (m *MockAutocompleteServiceServer) AutocompleteField(arg0 context.Context, arg1 *cloudpb.AutocompleteFieldRequest) (*cloudpb.AutocompleteFieldResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AutocompleteField", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.AutocompleteFieldResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AutocompleteField indicates an expected call of AutocompleteField.
func (mr *MockAutocompleteServiceServerMockRecorder) AutocompleteField(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutocompleteField", reflect.TypeOf((*MockAutocompleteServiceServer)(nil).AutocompleteField), arg0, arg1)
}

// MockConfigServiceClient is a mock of ConfigServiceClient interface.
type MockConfigServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockConfigServiceClientMockRecorder
}

// MockConfigServiceClientMockRecorder is the mock recorder for MockConfigServiceClient.
type MockConfigServiceClientMockRecorder struct {
	mock *MockConfigServiceClient
}

// NewMockConfigServiceClient creates a new mock instance.
func NewMockConfigServiceClient(ctrl *gomock.Controller) *MockConfigServiceClient {
	mock := &MockConfigServiceClient{ctrl: ctrl}
	mock.recorder = &MockConfigServiceClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockConfigServiceClient) EXPECT() *MockConfigServiceClientMockRecorder {
	return m.recorder
}

// GetConfigForOperator mocks base method.
func (m *MockConfigServiceClient) GetConfigForOperator(ctx context.Context, in *cloudpb.ConfigForOperatorRequest, opts ...grpc.CallOption) (*cloudpb.ConfigForOperatorResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConfigForOperator", varargs...)
	ret0, _ := ret[0].(*cloudpb.ConfigForOperatorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigForOperator indicates an expected call of GetConfigForOperator.
func (mr *MockConfigServiceClientMockRecorder) GetConfigForOperator(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigForOperator", reflect.TypeOf((*MockConfigServiceClient)(nil).GetConfigForOperator), varargs...)
}

// GetConfigForVizier mocks base method.
func (m *MockConfigServiceClient) GetConfigForVizier(ctx context.Context, in *cloudpb.ConfigForVizierRequest, opts ...grpc.CallOption) (*cloudpb.ConfigForVizierResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConfigForVizier", varargs...)
	ret0, _ := ret[0].(*cloudpb.ConfigForVizierResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigForVizier indicates an expected call of GetConfigForVizier.
func (mr *MockConfigServiceClientMockRecorder) GetConfigForVizier(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigForVizier", reflect.TypeOf((*MockConfigServiceClient)(nil).GetConfigForVizier), varargs...)
}

// MockConfigServiceServer is a mock of ConfigServiceServer interface.
type MockConfigServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockConfigServiceServerMockRecorder
}

// MockConfigServiceServerMockRecorder is the mock recorder for MockConfigServiceServer.
type MockConfigServiceServerMockRecorder struct {
	mock *MockConfigServiceServer
}

// NewMockConfigServiceServer creates a new mock instance.
func NewMockConfigServiceServer(ctrl *gomock.Controller) *MockConfigServiceServer {
	mock := &MockConfigServiceServer{ctrl: ctrl}
	mock.recorder = &MockConfigServiceServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockConfigServiceServer) EXPECT() *MockConfigServiceServerMockRecorder {
	return m.recorder
}

// GetConfigForOperator mocks base method.
func (m *MockConfigServiceServer) GetConfigForOperator(arg0 context.Context, arg1 *cloudpb.ConfigForOperatorRequest) (*cloudpb.ConfigForOperatorResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigForOperator", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.ConfigForOperatorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigForOperator indicates an expected call of GetConfigForOperator.
func (mr *MockConfigServiceServerMockRecorder) GetConfigForOperator(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigForOperator", reflect.TypeOf((*MockConfigServiceServer)(nil).GetConfigForOperator), arg0, arg1)
}

// GetConfigForVizier mocks base method.
func (m *MockConfigServiceServer) GetConfigForVizier(arg0 context.Context, arg1 *cloudpb.ConfigForVizierRequest) (*cloudpb.ConfigForVizierResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigForVizier", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.ConfigForVizierResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigForVizier indicates an expected call of GetConfigForVizier.
func (mr *MockConfigServiceServerMockRecorder) GetConfigForVizier(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigForVizier", reflect.TypeOf((*MockConfigServiceServer)(nil).GetConfigForVizier), arg0, arg1)
}

// MockPluginServiceClient is a mock of PluginServiceClient interface.
type MockPluginServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockPluginServiceClientMockRecorder
}

// MockPluginServiceClientMockRecorder is the mock recorder for MockPluginServiceClient.
type MockPluginServiceClientMockRecorder struct {
	mock *MockPluginServiceClient
}

// NewMockPluginServiceClient creates a new mock instance.
func NewMockPluginServiceClient(ctrl *gomock.Controller) *MockPluginServiceClient {
	mock := &MockPluginServiceClient{ctrl: ctrl}
	mock.recorder = &MockPluginServiceClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPluginServiceClient) EXPECT() *MockPluginServiceClientMockRecorder {
	return m.recorder
}

// CreateRetentionScript mocks base method.
func (m *MockPluginServiceClient) CreateRetentionScript(ctx context.Context, in *cloudpb.CreateRetentionScriptRequest, opts ...grpc.CallOption) (*cloudpb.CreateRetentionScriptResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRetentionScript", varargs...)
	ret0, _ := ret[0].(*cloudpb.CreateRetentionScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRetentionScript indicates an expected call of CreateRetentionScript.
func (mr *MockPluginServiceClientMockRecorder) CreateRetentionScript(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRetentionScript", reflect.TypeOf((*MockPluginServiceClient)(nil).CreateRetentionScript), varargs...)
}

// DeleteRetentionScript mocks base method.
func (m *MockPluginServiceClient) DeleteRetentionScript(ctx context.Context, in *cloudpb.DeleteRetentionScriptRequest, opts ...grpc.CallOption) (*cloudpb.DeleteRetentionScriptResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRetentionScript", varargs...)
	ret0, _ := ret[0].(*cloudpb.DeleteRetentionScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRetentionScript indicates an expected call of DeleteRetentionScript.
func (mr *MockPluginServiceClientMockRecorder) DeleteRetentionScript(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRetentionScript", reflect.TypeOf((*MockPluginServiceClient)(nil).DeleteRetentionScript), varargs...)
}

// GetOrgRetentionPluginConfig mocks base method.
func (m *MockPluginServiceClient) GetOrgRetentionPluginConfig(ctx context.Context, in *cloudpb.GetOrgRetentionPluginConfigRequest, opts ...grpc.CallOption) (*cloudpb.GetOrgRetentionPluginConfigResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrgRetentionPluginConfig", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetOrgRetentionPluginConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrgRetentionPluginConfig indicates an expected call of GetOrgRetentionPluginConfig.
func (mr *MockPluginServiceClientMockRecorder) GetOrgRetentionPluginConfig(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgRetentionPluginConfig", reflect.TypeOf((*MockPluginServiceClient)(nil).GetOrgRetentionPluginConfig), varargs...)
}

// GetPlugins mocks base method.
func (m *MockPluginServiceClient) GetPlugins(ctx context.Context, in *cloudpb.GetPluginsRequest, opts ...grpc.CallOption) (*cloudpb.GetPluginsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPlugins", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetPluginsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPlugins indicates an expected call of GetPlugins.
func (mr *MockPluginServiceClientMockRecorder) GetPlugins(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlugins", reflect.TypeOf((*MockPluginServiceClient)(nil).GetPlugins), varargs...)
}

// GetRetentionPluginInfo mocks base method.
func (m *MockPluginServiceClient) GetRetentionPluginInfo(ctx context.Context, in *cloudpb.GetRetentionPluginInfoRequest, opts ...grpc.CallOption) (*cloudpb.GetRetentionPluginInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRetentionPluginInfo", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetRetentionPluginInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRetentionPluginInfo indicates an expected call of GetRetentionPluginInfo.
func (mr *MockPluginServiceClientMockRecorder) GetRetentionPluginInfo(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetentionPluginInfo", reflect.TypeOf((*MockPluginServiceClient)(nil).GetRetentionPluginInfo), varargs...)
}

// GetRetentionScript mocks base method.
func (m *MockPluginServiceClient) GetRetentionScript(ctx context.Context, in *cloudpb.GetRetentionScriptRequest, opts ...grpc.CallOption) (*cloudpb.GetRetentionScriptResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRetentionScript", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetRetentionScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRetentionScript indicates an expected call of GetRetentionScript.
func (mr *MockPluginServiceClientMockRecorder) GetRetentionScript(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetentionScript", reflect.TypeOf((*MockPluginServiceClient)(nil).GetRetentionScript), varargs...)
}

// GetRetentionScripts mocks base method.
func (m *MockPluginServiceClient) GetRetentionScripts(ctx context.Context, in *cloudpb.GetRetentionScriptsRequest, opts ...grpc.CallOption) (*cloudpb.GetRetentionScriptsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRetentionScripts", varargs...)
	ret0, _ := ret[0].(*cloudpb.GetRetentionScriptsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRetentionScripts indicates an expected call of GetRetentionScripts.
func (mr *MockPluginServiceClientMockRecorder) GetRetentionScripts(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetentionScripts", reflect.TypeOf((*MockPluginServiceClient)(nil).GetRetentionScripts), varargs...)
}

// UpdateRetentionPluginConfig mocks base method.
func (m *MockPluginServiceClient) UpdateRetentionPluginConfig(ctx context.Context, in *cloudpb.UpdateRetentionPluginConfigRequest, opts ...grpc.CallOption) (*cloudpb.UpdateRetentionPluginConfigResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRetentionPluginConfig", varargs...)
	ret0, _ := ret[0].(*cloudpb.UpdateRetentionPluginConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRetentionPluginConfig indicates an expected call of UpdateRetentionPluginConfig.
func (mr *MockPluginServiceClientMockRecorder) UpdateRetentionPluginConfig(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRetentionPluginConfig", reflect.TypeOf((*MockPluginServiceClient)(nil).UpdateRetentionPluginConfig), varargs...)
}

// UpdateRetentionScript mocks base method.
func (m *MockPluginServiceClient) UpdateRetentionScript(ctx context.Context, in *cloudpb.UpdateRetentionScriptRequest, opts ...grpc.CallOption) (*cloudpb.UpdateRetentionScriptResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRetentionScript", varargs...)
	ret0, _ := ret[0].(*cloudpb.UpdateRetentionScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRetentionScript indicates an expected call of UpdateRetentionScript.
func (mr *MockPluginServiceClientMockRecorder) UpdateRetentionScript(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRetentionScript", reflect.TypeOf((*MockPluginServiceClient)(nil).UpdateRetentionScript), varargs...)
}

// MockPluginServiceServer is a mock of PluginServiceServer interface.
type MockPluginServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockPluginServiceServerMockRecorder
}

// MockPluginServiceServerMockRecorder is the mock recorder for MockPluginServiceServer.
type MockPluginServiceServerMockRecorder struct {
	mock *MockPluginServiceServer
}

// NewMockPluginServiceServer creates a new mock instance.
func NewMockPluginServiceServer(ctrl *gomock.Controller) *MockPluginServiceServer {
	mock := &MockPluginServiceServer{ctrl: ctrl}
	mock.recorder = &MockPluginServiceServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPluginServiceServer) EXPECT() *MockPluginServiceServerMockRecorder {
	return m.recorder
}

// CreateRetentionScript mocks base method.
func (m *MockPluginServiceServer) CreateRetentionScript(arg0 context.Context, arg1 *cloudpb.CreateRetentionScriptRequest) (*cloudpb.CreateRetentionScriptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRetentionScript", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.CreateRetentionScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRetentionScript indicates an expected call of CreateRetentionScript.
func (mr *MockPluginServiceServerMockRecorder) CreateRetentionScript(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRetentionScript", reflect.TypeOf((*MockPluginServiceServer)(nil).CreateRetentionScript), arg0, arg1)
}

// DeleteRetentionScript mocks base method.
func (m *MockPluginServiceServer) DeleteRetentionScript(arg0 context.Context, arg1 *cloudpb.DeleteRetentionScriptRequest) (*cloudpb.DeleteRetentionScriptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRetentionScript", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.DeleteRetentionScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRetentionScript indicates an expected call of DeleteRetentionScript.
func (mr *MockPluginServiceServerMockRecorder) DeleteRetentionScript(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRetentionScript", reflect.TypeOf((*MockPluginServiceServer)(nil).DeleteRetentionScript), arg0, arg1)
}

// GetOrgRetentionPluginConfig mocks base method.
func (m *MockPluginServiceServer) GetOrgRetentionPluginConfig(arg0 context.Context, arg1 *cloudpb.GetOrgRetentionPluginConfigRequest) (*cloudpb.GetOrgRetentionPluginConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrgRetentionPluginConfig", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetOrgRetentionPluginConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrgRetentionPluginConfig indicates an expected call of GetOrgRetentionPluginConfig.
func (mr *MockPluginServiceServerMockRecorder) GetOrgRetentionPluginConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgRetentionPluginConfig", reflect.TypeOf((*MockPluginServiceServer)(nil).GetOrgRetentionPluginConfig), arg0, arg1)
}

// GetPlugins mocks base method.
func (m *MockPluginServiceServer) GetPlugins(arg0 context.Context, arg1 *cloudpb.GetPluginsRequest) (*cloudpb.GetPluginsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPlugins", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetPluginsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPlugins indicates an expected call of GetPlugins.
func (mr *MockPluginServiceServerMockRecorder) GetPlugins(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlugins", reflect.TypeOf((*MockPluginServiceServer)(nil).GetPlugins), arg0, arg1)
}

// GetRetentionPluginInfo mocks base method.
func (m *MockPluginServiceServer) GetRetentionPluginInfo(arg0 context.Context, arg1 *cloudpb.GetRetentionPluginInfoRequest) (*cloudpb.GetRetentionPluginInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetentionPluginInfo", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetRetentionPluginInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRetentionPluginInfo indicates an expected call of GetRetentionPluginInfo.
func (mr *MockPluginServiceServerMockRecorder) GetRetentionPluginInfo(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetentionPluginInfo", reflect.TypeOf((*MockPluginServiceServer)(nil).GetRetentionPluginInfo), arg0, arg1)
}

// GetRetentionScript mocks base method.
func (m *MockPluginServiceServer) GetRetentionScript(arg0 context.Context, arg1 *cloudpb.GetRetentionScriptRequest) (*cloudpb.GetRetentionScriptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetentionScript", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetRetentionScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRetentionScript indicates an expected call of GetRetentionScript.
func (mr *MockPluginServiceServerMockRecorder) GetRetentionScript(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetentionScript", reflect.TypeOf((*MockPluginServiceServer)(nil).GetRetentionScript), arg0, arg1)
}

// GetRetentionScripts mocks base method.
func (m *MockPluginServiceServer) GetRetentionScripts(arg0 context.Context, arg1 *cloudpb.GetRetentionScriptsRequest) (*cloudpb.GetRetentionScriptsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetentionScripts", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.GetRetentionScriptsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRetentionScripts indicates an expected call of GetRetentionScripts.
func (mr *MockPluginServiceServerMockRecorder) GetRetentionScripts(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetentionScripts", reflect.TypeOf((*MockPluginServiceServer)(nil).GetRetentionScripts), arg0, arg1)
}

// UpdateRetentionPluginConfig mocks base method.
func (m *MockPluginServiceServer) UpdateRetentionPluginConfig(arg0 context.Context, arg1 *cloudpb.UpdateRetentionPluginConfigRequest) (*cloudpb.UpdateRetentionPluginConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRetentionPluginConfig", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.UpdateRetentionPluginConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRetentionPluginConfig indicates an expected call of UpdateRetentionPluginConfig.
func (mr *MockPluginServiceServerMockRecorder) UpdateRetentionPluginConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRetentionPluginConfig", reflect.TypeOf((*MockPluginServiceServer)(nil).UpdateRetentionPluginConfig), arg0, arg1)
}

// UpdateRetentionScript mocks base method.
func (m *MockPluginServiceServer) UpdateRetentionScript(arg0 context.Context, arg1 *cloudpb.UpdateRetentionScriptRequest) (*cloudpb.UpdateRetentionScriptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRetentionScript", arg0, arg1)
	ret0, _ := ret[0].(*cloudpb.UpdateRetentionScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRetentionScript indicates an expected call of UpdateRetentionScript.
func (mr *MockPluginServiceServerMockRecorder) UpdateRetentionScript(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRetentionScript", reflect.TypeOf((*MockPluginServiceServer)(nil).UpdateRetentionScript), arg0, arg1)
}
